using System.Runtime.CompilerServices;
using UnityEngine;

public static class EaseMethods
{
	private static Ease _backEaseIn;

	private static Ease _backEaseOut;

	private static Ease _backEaseInOut;

	private static Ease _bounceEaseIn;

	private static Ease _bounceEaseOut;

	private static Ease _bounceEaseInOut;

	private static Ease _circleEaseIn;

	private static Ease _circleEaseOut;

	private static Ease _circleEaseInOut;

	private static Ease _cubicEaseIn;

	private static Ease _cubicEaseOut;

	private static Ease _cubicEaseInOut;

	private static Ease _elasticEaseIn;

	private static Ease _elasticEaseOut;

	private static Ease _elasticEaseInOut;

	private static Ease _expoEaseIn;

	private static Ease _expoEaseOut;

	private static Ease _expoEaseInOut;

	private static Ease _linearEaseNone;

	private static Ease _linearEaseIn;

	private static Ease _linearEaseOut;

	private static Ease _linearEaseInOut;

	private static Ease _quadEaseIn;

	private static Ease _quadEaseOut;

	private static Ease _quadEaseInOut;

	private static Ease _quartEaseIn;

	private static Ease _quartEaseOut;

	private static Ease _quartEaseInOut;

	private static Ease _quintEaseIn;

	private static Ease _quintEaseOut;

	private static Ease _quintEaseInOut;

	private static Ease _sineEaseIn;

	private static Ease _sineEaseOut;

	private static Ease _sineEaseInOut;

	private static Ease _strongEaseIn;

	private static Ease _strongEaseOut;

	private static Ease _strongEaseInOut;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache0;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache1;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache2;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache3;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache4;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache5;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache6;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache7;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache8;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache9;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cacheA;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cacheB;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cacheC;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cacheD;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cacheE;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cacheF;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache10;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache11;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache12;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache13;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache14;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache15;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache16;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache17;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache18;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache19;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache1A;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache1B;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache1C;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache1D;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache1E;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache1F;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache20;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache21;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache22;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache23;

	[CompilerGenerated]
	private static Ease _003C_003Ef__mg_0024cache24;

	public static Ease BackEaseIn
	{
		get
		{
			if (_backEaseIn == null)
			{
				_backEaseIn = ConcreteEaseMethods.BackEaseIn;
			}
			return _backEaseIn;
		}
	}

	public static Ease BackEaseOut
	{
		get
		{
			if (_backEaseOut == null)
			{
				_backEaseOut = ConcreteEaseMethods.BackEaseOut;
			}
			return _backEaseOut;
		}
	}

	public static Ease BackEaseInOut
	{
		get
		{
			if (_backEaseInOut == null)
			{
				_backEaseInOut = ConcreteEaseMethods.BackEaseInOut;
			}
			return _backEaseInOut;
		}
	}

	public static Ease BounceEaseIn
	{
		get
		{
			if (_bounceEaseIn == null)
			{
				_bounceEaseIn = ConcreteEaseMethods.BounceEaseIn;
			}
			return _bounceEaseIn;
		}
	}

	public static Ease BounceEaseOut
	{
		get
		{
			if (_bounceEaseOut == null)
			{
				_bounceEaseOut = ConcreteEaseMethods.BounceEaseOut;
			}
			return _bounceEaseOut;
		}
	}

	public static Ease BounceEaseInOut
	{
		get
		{
			if (_bounceEaseInOut == null)
			{
				_bounceEaseInOut = ConcreteEaseMethods.BounceEaseInOut;
			}
			return _bounceEaseInOut;
		}
	}

	public static Ease CircleEaseIn
	{
		get
		{
			if (_circleEaseIn == null)
			{
				_circleEaseIn = ConcreteEaseMethods.CircleEaseIn;
			}
			return _circleEaseIn;
		}
	}

	public static Ease CircleEaseOut
	{
		get
		{
			if (_circleEaseOut == null)
			{
				_circleEaseOut = ConcreteEaseMethods.CircleEaseOut;
			}
			return _circleEaseOut;
		}
	}

	public static Ease CircleEaseInOut
	{
		get
		{
			if (_circleEaseInOut == null)
			{
				_circleEaseInOut = ConcreteEaseMethods.CircleEaseInOut;
			}
			return _circleEaseInOut;
		}
	}

	public static Ease CubicEaseIn
	{
		get
		{
			if (_cubicEaseIn == null)
			{
				_cubicEaseIn = ConcreteEaseMethods.CubicEaseIn;
			}
			return _cubicEaseIn;
		}
	}

	public static Ease CubicEaseOut
	{
		get
		{
			if (_cubicEaseOut == null)
			{
				_cubicEaseOut = ConcreteEaseMethods.CubicEaseOut;
			}
			return _cubicEaseOut;
		}
	}

	public static Ease CubicEaseInOut
	{
		get
		{
			if (_cubicEaseInOut == null)
			{
				_cubicEaseInOut = ConcreteEaseMethods.CubicEaseInOut;
			}
			return _cubicEaseInOut;
		}
	}

	public static Ease ElasticEaseIn
	{
		get
		{
			if (_elasticEaseIn == null)
			{
				_elasticEaseIn = ConcreteEaseMethods.ElasticEaseIn;
			}
			return _elasticEaseIn;
		}
	}

	public static Ease ElasticEaseOut
	{
		get
		{
			if (_elasticEaseOut == null)
			{
				_elasticEaseOut = ConcreteEaseMethods.ElasticEaseOut;
			}
			return _elasticEaseOut;
		}
	}

	public static Ease ElasticEaseInOut
	{
		get
		{
			if (_elasticEaseInOut == null)
			{
				_elasticEaseInOut = ConcreteEaseMethods.ElasticEaseInOut;
			}
			return _elasticEaseInOut;
		}
	}

	public static Ease ExpoEaseIn
	{
		get
		{
			if (_expoEaseIn == null)
			{
				_expoEaseIn = ConcreteEaseMethods.ExpoEaseIn;
			}
			return _expoEaseIn;
		}
	}

	public static Ease ExpoEaseOut
	{
		get
		{
			if (_expoEaseOut == null)
			{
				_expoEaseOut = ConcreteEaseMethods.ExpoEaseOut;
			}
			return _expoEaseOut;
		}
	}

	public static Ease ExpoEaseInOut
	{
		get
		{
			if (_expoEaseInOut == null)
			{
				_expoEaseInOut = ConcreteEaseMethods.ExpoEaseInOut;
			}
			return _expoEaseInOut;
		}
	}

	public static Ease LinearEaseNone
	{
		get
		{
			if (_linearEaseNone == null)
			{
				_linearEaseNone = ConcreteEaseMethods.LinearEaseNone;
			}
			return _linearEaseNone;
		}
	}

	public static Ease LinearEaseIn
	{
		get
		{
			if (_linearEaseIn == null)
			{
				_linearEaseIn = ConcreteEaseMethods.LinearEaseIn;
			}
			return _linearEaseIn;
		}
	}

	public static Ease LinearEaseOut
	{
		get
		{
			if (_linearEaseOut == null)
			{
				_linearEaseOut = ConcreteEaseMethods.LinearEaseOut;
			}
			return _linearEaseOut;
		}
	}

	public static Ease LinearEaseInOut
	{
		get
		{
			if (_linearEaseInOut == null)
			{
				_linearEaseInOut = ConcreteEaseMethods.LinearEaseInOut;
			}
			return _linearEaseInOut;
		}
	}

	public static Ease QuadEaseIn
	{
		get
		{
			if (_quadEaseIn == null)
			{
				_quadEaseIn = ConcreteEaseMethods.QuadEaseIn;
			}
			return _quadEaseIn;
		}
	}

	public static Ease QuadEaseOut
	{
		get
		{
			if (_quadEaseOut == null)
			{
				_quadEaseOut = ConcreteEaseMethods.QuadEaseOut;
			}
			return _quadEaseOut;
		}
	}

	public static Ease QuadEaseInOut
	{
		get
		{
			if (_quadEaseInOut == null)
			{
				_quadEaseInOut = ConcreteEaseMethods.QuadEaseInOut;
			}
			return _quadEaseInOut;
		}
	}

	public static Ease QuartEaseIn
	{
		get
		{
			if (_quartEaseIn == null)
			{
				_quartEaseIn = ConcreteEaseMethods.QuartEaseIn;
			}
			return _quartEaseIn;
		}
	}

	public static Ease QuartEaseOut
	{
		get
		{
			if (_quartEaseOut == null)
			{
				_quartEaseOut = ConcreteEaseMethods.QuartEaseOut;
			}
			return _quartEaseOut;
		}
	}

	public static Ease QuartEaseInOut
	{
		get
		{
			if (_quartEaseInOut == null)
			{
				_quartEaseInOut = ConcreteEaseMethods.QuartEaseInOut;
			}
			return _quartEaseInOut;
		}
	}

	public static Ease QuintEaseIn
	{
		get
		{
			if (_quintEaseIn == null)
			{
				_quintEaseIn = ConcreteEaseMethods.QuintEaseIn;
			}
			return _quintEaseIn;
		}
	}

	public static Ease QuintEaseOut
	{
		get
		{
			if (_quintEaseOut == null)
			{
				_quintEaseOut = ConcreteEaseMethods.QuintEaseOut;
			}
			return _quintEaseOut;
		}
	}

	public static Ease QuintEaseInOut
	{
		get
		{
			if (_quintEaseInOut == null)
			{
				_quintEaseInOut = ConcreteEaseMethods.QuintEaseInOut;
			}
			return _quintEaseInOut;
		}
	}

	public static Ease SineEaseIn
	{
		get
		{
			if (_sineEaseIn == null)
			{
				_sineEaseIn = ConcreteEaseMethods.SineEaseIn;
			}
			return _sineEaseIn;
		}
	}

	public static Ease SineEaseOut
	{
		get
		{
			if (_sineEaseOut == null)
			{
				_sineEaseOut = ConcreteEaseMethods.SineEaseOut;
			}
			return _sineEaseOut;
		}
	}

	public static Ease SineEaseInOut
	{
		get
		{
			if (_sineEaseInOut == null)
			{
				_sineEaseInOut = ConcreteEaseMethods.SineEaseInOut;
			}
			return _sineEaseInOut;
		}
	}

	public static Ease StrongEaseIn
	{
		get
		{
			if (_strongEaseIn == null)
			{
				_strongEaseIn = ConcreteEaseMethods.StrongEaseIn;
			}
			return _strongEaseIn;
		}
	}

	public static Ease StrongEaseOut
	{
		get
		{
			if (_strongEaseOut == null)
			{
				_strongEaseOut = ConcreteEaseMethods.StrongEaseOut;
			}
			return _strongEaseOut;
		}
	}

	public static Ease StrongEaseInOut
	{
		get
		{
			if (_strongEaseInOut == null)
			{
				_strongEaseInOut = ConcreteEaseMethods.StrongEaseInOut;
			}
			return _strongEaseInOut;
		}
	}

	public static Ease GetEase(EaseStyle style)
	{
		switch (style)
		{
		case EaseStyle.Linear:
			return LinearEaseNone;
		case EaseStyle.LinearEaseIn:
			return LinearEaseIn;
		case EaseStyle.LinearEaseOut:
			return LinearEaseOut;
		case EaseStyle.LinearEaseInOut:
			return LinearEaseInOut;
		case EaseStyle.BackEaseIn:
			return BackEaseIn;
		case EaseStyle.BackEaseOut:
			return BackEaseOut;
		case EaseStyle.BackEaseInOut:
			return BackEaseInOut;
		case EaseStyle.BounceEaseIn:
			return BounceEaseIn;
		case EaseStyle.BounceEaseOut:
			return BounceEaseOut;
		case EaseStyle.BounceEaseInOut:
			return BounceEaseInOut;
		case EaseStyle.CircleEaseIn:
			return CircleEaseIn;
		case EaseStyle.CircleEaseOut:
			return CircleEaseOut;
		case EaseStyle.CircleEaseInOut:
			return CircleEaseInOut;
		case EaseStyle.CubicEaseIn:
			return CubicEaseIn;
		case EaseStyle.CubicEaseOut:
			return CubicEaseOut;
		case EaseStyle.CubicEaseInOut:
			return CubicEaseInOut;
		case EaseStyle.ElasticEaseIn:
			return ElasticEaseIn;
		case EaseStyle.ElasticEaseOut:
			return ElasticEaseOut;
		case EaseStyle.ElasticEaseInOut:
			return ElasticEaseInOut;
		case EaseStyle.ExpoEaseIn:
			return ExpoEaseIn;
		case EaseStyle.ExpoEaseOut:
			return ExpoEaseOut;
		case EaseStyle.ExpoEaseInOut:
			return ExpoEaseInOut;
		case EaseStyle.QuadEaseIn:
			return QuadEaseIn;
		case EaseStyle.QuadEaseOut:
			return QuadEaseOut;
		case EaseStyle.QuadEaseInOut:
			return QuadEaseInOut;
		case EaseStyle.QuartEaseIn:
			return QuartEaseIn;
		case EaseStyle.QuartEaseOut:
			return QuartEaseOut;
		case EaseStyle.QuartEaseInOut:
			return QuartEaseInOut;
		case EaseStyle.QuintEaseIn:
			return QuintEaseIn;
		case EaseStyle.QuintEaseOut:
			return QuintEaseOut;
		case EaseStyle.QuintEaseInOut:
			return QuintEaseInOut;
		case EaseStyle.SineEaseIn:
			return SineEaseIn;
		case EaseStyle.SineEaseOut:
			return SineEaseOut;
		case EaseStyle.SineEaseInOut:
			return SineEaseInOut;
		case EaseStyle.StrongEaseIn:
			return StrongEaseIn;
		case EaseStyle.StrongEaseOut:
			return StrongEaseOut;
		case EaseStyle.StrongEaseInOut:
			return StrongEaseInOut;
		default:
			return null;
		}
	}

	public static float EasedLerp(Ease ease, float from, float to, float t)
	{
		return ease(t, from, to - from, 1f);
	}

	public static Ease FromAnimationCurve(AnimationCurve curve)
	{
		return (float c, float s, float e, float d) => curve.Evaluate(c);
	}

	public static Ease CubicBezier(float p0, float p1, float p2, float p3)
	{
		return delegate(float c, float s, float e, float d)
		{
			float num = c / d;
			float num2 = 1f - num;
			float num3 = Mathf.Pow(num2, 3f) * p0 + 3f * Mathf.Pow(num2, 2f) * num * p1 + 3f * num2 * Mathf.Pow(num, 2f) * p2 + Mathf.Pow(num, 3f) * p3;
			return s + e * num3;
		};
	}

	public static Vector2 EaseVector2(Ease ease, Vector2 start, Vector2 end, float t, float dur)
	{
		return ease(t, 0f, 1f, dur) * (end - start) + start;
	}

	public static Vector3 EaseVector3(Ease ease, Vector3 start, Vector3 end, float t, float dur)
	{
		return ease(t, 0f, 1f, dur) * (end - start) + start;
	}

	public static Vector4 EaseVector4(Ease ease, Vector4 start, Vector4 end, float t, float dur)
	{
		return ease(t, 0f, 1f, dur) * (end - start) + start;
	}

	public static Quaternion EaseQuaternion(Ease ease, Quaternion start, Quaternion end, float t, float dur)
	{
		return Quaternion.Slerp(start, end, ease(t, 0f, 1f, dur));
	}
}
